Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/Slider.tsx`:
- Around line 191-206: The aggregated disabled computation is inconsistent with
per-handle checks: update the computed "disabled" (currently using
rawDisabled.every) to consider the current number of handles (use
rawValues.length) so it only returns true when rawDisabled is an array of length
equal to rawValues.length and every entry is truthy; keep isHandleDisabled
(function name) as-is but ensure it still falls back to false for missing
indices. In short, change the logic for disabled to: if rawDisabled is boolean
return it; if it's an array, return rawDisabled.length === rawValues.length &&
rawDisabled.every(Boolean); leave isHandleDisabled(index) unchanged.

In `@tests/Range.test.tsx`:
- Around line 985-1005: The test's claim that it covers the nearestIndex === -1
path is incorrect because with disabled={[true,true,true]} the
changeToCloseValue early-returns at if (!disabled), so the nearestIndex branch
is never reached; either remove or update the misleading comment/description in
the it(...) block, or replace the test with one that actually executes the
nearestIndex === -1 branch by ensuring changeToCloseValue runs (e.g., make at
least one handle enabled and construct a click position that yields nearestIndex
=== -1 so the code path in Slider.tsx referencing nearestIndex is exercised);
refer to the test case name in Range.test.tsx and the changeToCloseValue /
nearestIndex symbols to locate where to change the test and its assertion.
- Around line 961-983: The test for "draggableTrack disabled when any handle is
disabled" is likely a false positive because it builds a custom
mouseDown/mouseMove sequence that doesn't match the track drag startup used
elsewhere; reuse the existing doMouseMove helper so the test exercises the same
drag path and ensure the mouseDown event includes pageX/pageY getters and a
preventDefault implementation (and set pageX/pageY on the mouseMove) so the
draggableTrack logic is triggered; update the spec to call doMouseMove (or
mirror its behavior) when interacting with the rc-slider-track and assert
onChange remains uncalled when one handle is disabled.

---

Outside diff comments:
In `@src/Slider.tsx`:
- Around line 341-355: The onDelete handler (and corresponding insert logic
around the insert function at lines ~399-408) mutates rawValues but leaves the
parallel disabled[] array indexed to original handles, causing disabled flags to
shift; update the implementation so editable mode keeps per-handle metadata in
sync with values—either splice the disabled array the same way you splice
rawValues (e.g., cloneDisabled.splice(index,1) on delete and
cloneDisabled.splice(index,0,newFlag) on insert) and pass the updated disabled
array/state through the same change flow, or introduce a single array of handle
metadata (e.g., handleMeta[]) that is kept in lockstep with rawValues and is
updated in onDelete, onInsert, and wherever values change; ensure
isHandleDisabled and any callers read from this synchronized source rather than
the original static disabled[] prop.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@docs/examples/disabled-handle.tsx`:
- Around line 55-58: The description text is inconsistent with the initial state
of BasicDisabledHandle (disabled=[true, false, false, true]) which disables
track dragging; update the paragraph so it accurately reflects behavior (e.g.,
"When any handle is disabled, track dragging is disabled; toggle checkboxes to
enable/disable handles and, when all handles are enabled, drag the track to move
the range.") or alternatively change BasicDisabledHandle's initial disabled
array to match the original description; refer to the JSX around
BasicDisabledHandle and the paragraph node that currently reads "Drag the track
area to move the range" to apply the fix.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/Slider.tsx`:
- Around line 190-210: The disabled calculation references rawValues before it
is declared causing the ESLint "'rawValues' was used before it was defined"
error; move the useMemo that defines disabled and the useCallback
isHandleDisabled to after rawValues is declared (or refactor them to compute
lazily so they read rawValues at call time), update their dependency arrays to
include rawValues and rawDisabled, and then relocate or re-evaluate any callers
(notably useOffset which depends on isHandleDisabled) so useOffset is invoked
after these definitions—alternatively split isHandleDisabled into a part that
doesn't depend on rawValues (e.g., boolean rawDisabled check) and a part that
uses rawValues to avoid reordering large blocks.

---

Outside diff comments:
In `@src/Slider.tsx`:
- Around line 508-517: The effect watching keyboardValue is missing rawValues in
its dependency array which can cause stale closures; update the React.useEffect
(the effect that references keyboardValue, rawValues, handlesRef, and calls
setKeyboardValue) to include rawValues in the dependency array (i.e.,
[keyboardValue, rawValues]) so the valueIndex lookup uses the current rawValues;
if rawValues is not stable, ensure it's memoized (e.g., via useMemo) or derive a
stable key instead to avoid excessive re-renders.
- Around line 536-543: The effect that auto-focuses the updated handle is
missing dependencies and can read stale values; update the useEffect dependency
array to include draggingValue and rawValues (in addition to dragging) and
inside the effect recompute valueIndex = rawValues.lastIndexOf(draggingValue)
when dragging is false, guarding that handlesRef.current exists and valueIndex
is valid before calling handlesRef.current.focus(valueIndex); keep the existing
dragging boolean (draggingIndex !== -1) and use the same symbols (dragging,
draggingValue, rawValues, handlesRef) so the hook reruns with fresh values.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@docs/examples/disabled-handle.tsx`:
- Around line 112-116: The paragraph text is inaccurate: because the component
DraggableTrackWithDisabled is initialized with
disabled={[true,false,false,true], and the Tracks implementation disables track
dragging whenever any handle is disabled, track dragging is actually disabled
here; update the paragraph copy to state that track dragging is disabled when
any handle is disabled (or alternatively change the disabled prop on
DraggableTrackWithDisabled to only disable the middle handles if you want
dragging enabled) and mention the disabled prop so the example and description
match actual behavior.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/Slider.tsx`:
- Around line 411-433: The current fallback that finds the nearest enabled
handle when isHandleDisabled(valueIndex) is true (using rawValues, newValue and
nearestIndex) can pick a handle across a disabled boundary and allow handles to
jump past disabled handles; change the search in that block so candidates are
limited to handles that can be reached without crossing any disabled handle
between the original index and the candidate: when scanning rawValues for a
nearestIndex, skip any candidate if any index between the original valueIndex
and that candidate is disabled (i.e., ensure the move path contains no disabled
handles), or alternatively restrict the search to the contiguous enabled segment
around the clicked position; update the logic that sets
cloneNextValues[valueIndex], valueIndex and focusIndex accordingly so you never
select a nearestIndex that requires crossing a disabled handle (refer to
isHandleDisabled, rawValues, valueIndex, newValue, cloneNextValues, focusIndex).
- Around line 191-197: The current disabled aggregation in the useMemo (symbols:
rawDisabled, value, disabled) only compares rawDisabled.length to value.length
and thus misses uncontrolled/default handles; change the logic to mirror how
effective handle count is computed elsewhere by using rawValues (or the same
helper that yields rawValues) instead of value when determining expected length
and in the dependency array so disabled is true when rawDisabled aligns with the
actual rendered handles (e.g., use rawValues.length and depend on rawValues,
rawDisabled).